package com.zhijian.medical.enums.diagnose.report;

import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.extern.slf4j.Slf4j;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * 乳腺癌报告枚举
 */
@Slf4j
public class BreastEnum {

    /**
     * 标本名称
     */
    @AllArgsConstructor
    @Getter
    public enum SampleNameEnum {

        GASTRIC_TISSUE("gastric_tissue", "胃组织"),
        ANASTOMOSIS_NEAR_END("anastomosis_near_end", "吻合口近端"),
        ANASTOMOSIS_REMOTE_END("anastomosis_remote_end", "吻合口远端");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(SampleNameEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 标本类型
     */
    @AllArgsConstructor
    @Getter
    public enum SampleTypeEnum {
        //（改良）根治标本 （改良）根治标本，乳腺肿块切除后  单纯切除标本  保乳标本

        //（改良）根治标本
        RADICAL("radical", "（改良）根治标本"),

        //改良）根治标本，乳腺肿块切除后
        RADICAL_WITH_BREAST_TUMOR("radical_with_breast_tumor", "（改良）根治标本，乳腺肿块切除后"),

        //单纯切除标本
        SIMPLE_REMOVAL("simple_removal", "单纯切除标本"),

        //保乳标本
        BREAST_SURGERY("breast_surgery", "保乳标本");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(SampleTypeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }

    }

    /**
     * 标本部位
     */
    @AllArgsConstructor
    @Getter
    public enum SamplePartEnum {
        //左乳 右乳
        LEFT("left", "左乳"),
        RIGHT("right", "右乳");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(SamplePartEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }

    }

    /**
     * 病灶位置
     */
    @AllArgsConstructor
    @Getter
    public enum TumorLocationEnum {
        //内上象限 内下象限 外上象限 外下象限 中央 其他 无法评估
        INNER_UP("inner_up", "内上象限"),
        INNER_DOWN("inner_down", "内下象限"),
        OUTER_UP("outer_up", "外上象限"),
        OUTER_DOWN("outer_down", "外下象限"),
        MIDDLE("middle", "中央"),
        OTHER("other", "其他"),
        UNEVALUABLE("unevaluable", "无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(TumorLocationEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 病灶大小
     */
    @AllArgsConstructor
    @Getter
    public enum TumorSizeEnum {

        S3("3.5x2.0", "3.5x2.0"),
        S20("20x16x3", "20x16x3");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(TumorSizeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 浸润性癌灶数量
     */
    @AllArgsConstructor
    @Getter
    public enum TumorNumberEnum {
        //单个浸润癌灶 多个浸润癌灶 未见
        SINGLE("single", "单个浸润癌灶"),
        MULTIPLE("multiple", "多个浸润癌灶"),
        NOT_FOUND("not_found", "未见");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(TumorNumberEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 组织学类型
     */
    @AllArgsConstructor
    @Getter
    public enum HistologicalTypeEnum {
        //主要的 化生性癌 乳头状肿瘤 非浸润性小叶性肿瘤
        MAIN("main", "主要的", HistologicalTypeMainEnum.getList()),
        ADENOCARCINOMA("adenocarcinoma", "化生性癌", HistologicalTypeAdenocarcinomaEnum.getList()),
        PAPILLOMA("papilloma", "乳头状肿瘤", HistologicalTypePapillomaEnum.getList()),
        NON_INVASIVE_LIQUID_BREAST_TUMOR("non_invasive_liquid_breast_tumor", "非浸润性小叶性肿瘤", NonInvasiveLiquidBreastTumorEnum.getList());

        private final String key;
        private final String desc;
        private final List<MappingEnum<String, String>> child;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(HistologicalTypeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), e.getChild()))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 组织学类型-主要
     */
    @AllArgsConstructor
    @Getter
    public enum HistologicalTypeMainEnum {
        //乳腺浸润性癌，非特殊类型 伴有髓样特征的浸润性乳腺癌，非特殊类型 微浸润性癌  浸润性小叶癌，经典型 浸润性小叶癌，实性型 浸润性小叶癌，多形性 浸润性小叶癌，混合型 小管癌 筛状癌 粘液癌A型 粘液癌B型 粘液癌 伴有癌的腺肌上皮瘤 腺肌上皮癌 伴大汗腺分化的癌 浸润性微乳头状癌 混合性癌
        BREAST_CARCINOMA("breast_carcinoma", "乳腺浸润性癌，非特殊类型"),
        BREAST_CARCINOMA_WITH_MESOTHELIOMA("breast_carcinoma_with_mesothelioma", "伴有髓样特征的浸润性乳腺癌，非特殊类型"),
        INVASIVE_LIQUID_BREAST_TUMOR("invasive_liquid_breast_tumor", "微浸润性癌"),
        INVASIVE_LIQUID_BREAST_TUMOR_CLASSICAL("invasive_liquid_breast_tumor_classical", "浸润性小叶癌，经典型"),
        INVASIVE_LIQUID_BREAST_TUMOR_SOLID("invasive_liquid_breast_tumor_solid", "浸润性小叶癌，实性型"),
        INVASIVE_LIQUID_BREAST_TUMOR_POLYPOID("invasive_liquid_breast_tumor_polyoid", "浸润性小叶癌，多形性"),
        INVASIVE_LIQUID_BREAST_TUMOR_MIXED("invasive_liquid_breast_tumor_mixed", "浸润性小叶癌，混合型"),
        TUBULAR_CARCINOMA("tubular_carcinoma", "小管癌"),
        PAPILLOMA("papilloma", "筛状癌"),
        MUCINOUS_CARCINOMA_A("mucinous_carcinoma_a", "粘液癌A型"),
        MUCINOUS_CARCINOMA_B("mucinous_carcinoma_b", "粘液癌B型"),
        MUCINOUS_CARCINOMA("mucinous_carcinoma", "粘液癌"),
        ADENOSQUAMOUS_CARCINOMA("adenosquamous_carcinoma", "伴有癌的腺肌上皮瘤"),
        ADENOSQUAMOUS_CARCINOMA_WITH_HYPERPLASIA("adenosquamous_carcinoma_with_hyperplasia", "腺肌上皮癌"),
        ADENOSQUAMOUS_CARCINOMA_WITH_HYPERPLASIA_WITH_HYPERSECRETION("adenosquamous_carcinoma_with_hyperplasia_with_hypersecretion", "伴大汗腺分化的癌"),
        INVASIVE_MICROPODIUM_CARCINOMA("invasive_micropodium_carcinoma", "浸润性微乳头状癌"),
        MIXED_CARCINOMA("mixed_carcinoma", "混合性癌");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(HistologicalTypeMainEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 组织学类型-化生性癌
     */
    @AllArgsConstructor
    @Getter
    public enum HistologicalTypeAdenocarcinomaEnum {
        //低級别腺鳞癌 纤维瘤病样化生性癌 鳞形细胞癌 梭形细胞癌 伴异源性间叶分化的化生性癌 混合性化生性癌
        LOW_GRADE_ADENOSQUAMOUS_CARCINOMA("low_grade_adenosquamous_carcinoma", "低级别腺鳞癌"),
        FIBROBLASTIC_CARCINOMA("fibroblastic_carcinoma", "纤维瘤病样化生性癌"),
        SQUAMOUS_CELL_CARCINOMA("squamous_cell_carcinoma", "鳞形细胞癌"),
        SKELETAL_CELL_CARCINOMA("skeletal_cell_carcinoma", "梭形细胞癌"),
        ADENOSQUAMOUS_CARCINOMA_WITH_HETEROTROPIC_MESODERMAL_DIFFERENTIATION("adenosquamous_carcinoma_with_heterotrophic_mesodermal_differentiation", "伴异源性间叶分化的化生性癌"),
        MIXED_CARCINOMA("mixed_carcinoma", "混合性化生性癌");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(HistologicalTypeAdenocarcinomaEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 组织学类型-乳头状肿瘤
     */
    @AllArgsConstructor
    @Getter
    public enum HistologicalTypePapillomaEnum {
        //导管内乳头状瘤  导管内乳头状瘤伴非典型导管上皮增生 导管内乳头状瘤伴导管原位癌 乳头状导管原位癌 浸润性乳头状癌 包裹性乳头状癌 包裹性乳头状癌伴浸润 原位实性乳头状癌 实性乳头状癌伴浸润
        INTRADUCTAL_PAPILLOMA("intraductal_papilloma", "导管内乳头状瘤"),
        INTRADUCTAL_PAPILLOMA_WITH_ATYPICAL_DUCTAL_EPITHELIUM_HYPERPLASIA("intraductal_papilloma_with_atypical_ductal_epithelium_hyperplasia", "导管内乳头状瘤伴非典型导管上皮增生"),
        INTRADUCTAL_PAPILLOMA_WITH_DUCTAL_CARCINOMA_IN_SITU("intraductal_papilloma_with_ductal_carcinoma_in_situ", "导管内乳头状瘤伴导管原位癌"),
        PAPILLOMA_WITH_DUCTAL_CARCINOMA_IN_SITU("papilloma_with_ductal_carcinoma_in_situ", "乳头状导管原位癌"),
        INVASIVE_PAPILLOMA("invasive_papilloma", "浸润性乳头状癌"),
        ENCAPSULATED_PAPILLOMA("encapsulated_papilloma", "包裹性乳头状癌"),
        ENCAPSULATED_PAPILLOMA_WITH_INVASIVE("encapsulated_papilloma_with_invasive", "包裹性乳头状癌伴浸润"),
        INTRADUCTAL_PAPILLOMA_WITH_DUCTAL_CARCINOMA("intraductal_papilloma_with_ductal_carcinoma", "原位实性乳头状癌"),
        INVASIVE_PAPILLOMA_WITH_PAPILLOMA("invasive_papilloma_with_papilloma", "实性乳头状癌伴浸润");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(HistologicalTypePapillomaEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 非浸润性小叶性肿瘤
     */
    @AllArgsConstructor
    @Getter
    public enum NonInvasiveLiquidBreastTumorEnum {
        //非典型小叶增生  小叶原位癌NOS 经典型小叶原位癌 旺炽型小叶原位癌  多形性小叶原位癌
        ATYPICAL_LIQUID_BREAST_TUMOR("atypical_liquid_breast_tumor", "非典型小叶增生"),
        LIQUID_BREAST_TUMOR_IN_SITU_NOS("liquid_breast_tumor_in_situ_nos", "小叶原位癌NOS"),
        CLASSICAL_LIQUID_BREAST_TUMOR("classical_liquid_breast_tumor", "经典型小叶原位癌"),
        PROLIFERATIVE_LIQUID_BREAST_TUMOR("proliferative_liquid_breast_tumor", "旺炽型小叶原位癌"),
        POLYPOID_LIQUID_BREAST_TUMOR("polyoid_liquid_breast_tumor", "多形性小叶原位癌");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NonInvasiveLiquidBreastTumorEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 百分比
     */
    @AllArgsConstructor
    @Getter
    public enum PercentageEnum {

        P0(0, "0"),
        P10(10, "10"),
        P20(20, "20"),
        P30(30, "30"),
        P40(40, "40"),
        P50(50, "50"),
        P60(60, "60"),
        P70(70, "70"),
        P80(80, "80"),
        P90(90, "90"),
        P100(100, "100");

        private final Integer key;
        private final String desc;

        private static final List<MappingEnum<Integer, String>> TEMP_MAPPING = Arrays.stream(PercentageEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<Integer, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 腺管形成
     */
    @AllArgsConstructor
    @Getter
    public enum DuctalFormationEnum {
        //1 2 3
        DUCTAL_FORMATION_1("ductal_formation_1", "1"),
        DUCTAL_FORMATION_2("ductal_formation_2", "2"),
        DUCTAL_FORMATION_3("ductal_formation_3", "3");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(DuctalFormationEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 核多形性
     */
    @AllArgsConstructor
    @Getter
    public enum NucleiMultiformityEnum {
        //1 2 3
        NUCLEI_MULTIFORMITY_1("nuclei_multiformity_1", "1"),
        NUCLEI_MULTIFORMITY_2("nuclei_multiformity_2", "2"),
        NUCLEI_MULTIFORMITY_3("nuclei_multiformity_3", "3");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NucleiMultiformityEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 核分裂计数
     */
    @AllArgsConstructor
    @Getter
    public enum NucleiMitosisCountEnum {
        //1 2 3
        NUCLEI_MITOSIS_COUNT_1("nuclei_mitosis_count_1", "1"),
        NUCLEI_MITOSIS_COUNT_2("nuclei_mitosis_count_2", "2"),
        NUCLEI_MITOSIS_COUNT_3("nuclei_mitosis_count_3", "3");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NucleiMitosisCountEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 组织学类型-等级
     */
    @AllArgsConstructor
    @Getter
    public enum HistologicalTypeGradeEnum {
        //I级 II级 III级
        GRADE_I("grade_i", "I级"),
        GRADE_II("grade_ii", "II级"),
        GRADE_III("grade_iii", "III级");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(HistologicalTypeGradeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 原位癌
     */
    @AllArgsConstructor
    @Getter
    public enum InSituCancerEnum {
        //导管原位癌 小叶原位癌，经典型 小叶原位癌，旺炽性 小叶原位癌，多形性 Paget's病 未见 其他
        DUCTAL_CARCINOMA_IN_SITU("ductal_carcinoma_in_situ", "导管原位癌"),
        LIQUID_BREAST_TUMOR_IN_SITU_CLASSICAL("liquid_breast_tumor_in_situ_classical", "小叶原位癌，经典型"),
        LIQUID_BREAST_TUMOR_IN_SITU_PROLIFERATIVE("liquid_breast_tumor_in_situ_proliferative", "小叶原位癌，旺炽性"),
        LIQUID_BREAST_TUMOR_IN_SITU_POLYPOID("liquid_breast_tumor_in_situ_polyoid", "小叶原位癌，多形性"),
        PAGET("paget", "Paget's病"),
        NOT_FOUND("not_found", "未见"),
        OTHER("other", "其他");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(InSituCancerEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 原位癌-百分比
     */
    @AllArgsConstructor
    @Getter
    public enum InSituCancerPercentageEnum {
        //0 1 5 10 20 30 40 50 60 70 80 90 100
        P0("p0", "0"),
        P1("p1", "1"),
        P5("p5", "5"),
        P10("p10", "10"),
        P20("p20", "20"),
        P30("p30", "30"),
        P40("p40", "40"),
        P50("p50", "50"),
        P60("p60", "60"),
        P70("p70", "70"),
        P80("p80", "80"),
        P90("p90", "90"),
        P100("p100", "100");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(InSituCancerPercentageEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 核级
     */
    @AllArgsConstructor
    @Getter
    public enum NucleiGradeEnum {
        //高 中 低
        HIGH("high", "高"),
        MIDDLE("middle", "中"),
        LOW("low", "低");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NucleiGradeEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 坏死
     */
    @AllArgsConstructor
    @Getter
    public enum NecrosisEnum {
        //未见 点状坏死 粉刺样坏死
        NOT_FOUND("not_found", "未见"),
        POINT("point", "点状坏死"),
        PUSTULE("pustule", "粉刺样坏死");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NecrosisEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 钙化
     */
    @AllArgsConstructor
    @Getter
    public enum CalcificationEnum {
        //可见 未见
        VISIBLE("visible", "可见"),
        NOT_FOUND("not_found", "未见");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(CalcificationEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 肿瘤间质浸润淋巴细胞sTILs
     */
    @AllArgsConstructor
    @Getter
    public enum TILsEnum {
        //0 1% 5% 10% 20% 30% 40% 50% 60% 70% 80% 90% 100% 无法评估
        P0("p0", "0"),
        P1("p1", "1%"),
        P5("p5", "5%"),
        P10("p10", "10%"),
        P20("p20", "20%"),
        P30("p30", "30%"),
        P40("p40", "40%"),
        P50("p50", "50%"),
        P60("p60", "60%"),
        P70("p70", "70%"),
        P80("p80", "80%"),
        P90("p90", "90%"),
        P100("p100", "100%"),
        UNABLE_TO_EVALUATE("unable_to_evaluate", "无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(TILsEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 脉管癌栓
     */
    @AllArgsConstructor
    @Getter
    public enum VascularCancerThrombusEnum {

        NOT_YET_SEEN("not_yet_seen", "末见癌栓"),
        VISIBLE("visible", "见癌栓"),
        SUSPICIOUS("suspicious", "可疑"),
        UNABLE_TO_EVALUATE("unable_to_evaluate", "无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(VascularCancerThrombusEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 神经侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum NeurologicalInvasionEnum {

        NOT_YET_SEEN("not_yet_seen", "未见侵犯"),
        VISIBLE("visible", "见侵犯"),
        SUSPICIOUS("suspicious", "可疑"),
        UNABLE_TO_EVALUATE("unable_to_evaluate", "无法评估");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NeurologicalInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 乳头侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum NippleInvasionEnum {
        //(-) (+) (/) 未送检
        NOT_SEEN("not_seen", "(-)"),
        SEEN("seen", "(+)"),
        UNABLE_TO_EVALUATE("unable_to_evaluate", "(/)"),
        NOT_SENT("not_sent", "未送检");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(NippleInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 皮肤侵犯
     */
    @AllArgsConstructor
    @Getter
    public enum SkinInvasionEnum {
        //(-) (+) (/) 未送检
        NOT_SEEN("not_seen", "(-)"),
        SEEN("seen", "(+)"),
        UNABLE_TO_EVALUATE("unable_to_evaluate", "(/)"),
        NOT_SENT("not_sent", "未送检");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(SkinInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 淋巴结
     */
    @AllArgsConstructor
    @Getter
    public enum LymphGlandEnum {

        NOT_TRANSFERRED("not_transferred", "未见转移"),
        SEE_TRANSFER("see_transfer", "见转移"),
        GRANULOMATOUS_INFLAMMATION("granulomatous_inflammation", "肉芽肿性炎"),
        ADIPOSE_TISSUE("adipose_tissue", "脂肪组织"),
        OTHER("other", "其他");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(LymphGlandEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 淋巴结结外侵犯（ENE）
     */
    @AllArgsConstructor
    @Getter
    public enum LymphGlandExtraluminalInvasionEnum {
        //有 无
        YES("yes", "有"),
        NO("no", "无");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(LymphGlandExtraluminalInvasionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * TNM分期-TNM分期
     */
    @AllArgsConstructor
    @Getter
    public enum LesionTnmStageEnum {
        //rp yp mp p
        RP("rp", "rp"),
        YP("yp", "yp"),
        MP("mp", "mp"),
        P("p", "p");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(LesionTnmStageEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 病理分期-T
     */
    @AllArgsConstructor
    @Getter
    public enum PathologicalStageTEnum {
        //Tx T0 Tis Tis(DCIS) Tis(Paget) T1mi T1a T1b T1c T2  T3 T4a T4b T4c T4d
        TX("tx", "Tx"),
        T0("t0", "T0"),
        TIS("tis", "Tis"),
        TIS_DCIS("tis_dcis", "Tis(DCIS)"),
        TIS_PAGET("tis_paget", "Tis(Paget)"),
        T1MI("t1mi", "T1mi"),
        T1A("t1a", "T1a"),
        T1B("t1b", "T1b"),
        T1C("t1c", "T1c"),
        T2("t2", "T2"),
        T3("t3", "T3"),
        T4A("t4a", "T4a"),
        T4B("t4b", "T4b"),
        T4C("t4c", "T4c"),
        T4D("t4d", "T4d");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PathologicalStageTEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 病理分期-N
     */
    @AllArgsConstructor
    @Getter
    public enum PathologicalStageNEnum {
        //Nx N0 N0(i+) N1mi N1a N1b N1c N2a N2b N3a N3b N3c
        NX("nx", "Nx"),
        N0("n0", "N0"),
        N0_I_PLUS("n0_i_plus", "N0(i+)"),
        N1MI("n1mi", "N1mi"),
        N1A("n1a", "N1a"),
        N1B("n1b", "N1b"),
        N1C("n1c", "N1c"),
        N2A("n2a", "N2a"),
        N2B("n2b", "N2b"),
        N3A("n3a", "N3a"),
        N3B("n3b", "N3b"),
        N3C("n3c", "N3c");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PathologicalStageNEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 病理分期-M
     */
    @AllArgsConstructor
    @Getter
    public enum PathologicalStageMEnum {
        //cM0 cM1 pM1
        CM0("cm0", "cM0"),
        CM1("cm1", "cM1"),
        PM1("pm1", "pM1");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PathologicalStageMEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 病理分期-总分期
     */
    @AllArgsConstructor
    @Getter
    public enum PathologicalStageTotalEnum {
       //0 IA IB IIA IIB IIIA IIIB IIIC IV
        ZERO("zero", "0"),
        IA("ia", "IA"),
        IB("ib", "IB"),
        IIA("iia", "IIA"),
        IIB("iib", "IIB"),
        IIIA("iiia", "IIIA"),
        IIIB("iiib", "IIIB"),
        IIIC("iiic", "IIIC"),
        IV("iv", "IV");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(PathologicalStageTotalEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 免疫组化-分析结果
     */
    @AllArgsConstructor
    @Getter
    public enum ResultEnum {

        REDUCE("-", "-"),
        PLUS("+", "+"),
        PLUS2("++", "++"),
        PLUS3("+++", "+++"),
        PLUS_OR_MINUS("±", "±");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(ResultEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 免疫组化-其他表达
     */
    @AllArgsConstructor
    @Getter
    public enum OtherExpressionEnum {
        // 肌上皮细胞 间质免疫细胞  脉管 其他
        MYOEPITHELIUM("myoepithelium", "肌上皮细胞"),
        INTERSTITIAL_IMMUNE_CELL("interstitial_immune_cell", "间质免疫细胞"),
        VASCULAR("vascular", "脉管"),
        OTHER("other", "其他");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(OtherExpressionEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }


    /**
     * 免疫组化-PDL1-分析结果
     */
    @AllArgsConstructor
    @Getter
    public enum Pdl1ResultEnum {
        // 低表达 高表达
        LOW_EXPRESSION("low_expression", "低表达"),
        HIGH_EXPRESSION("high_expression", "高表达");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(Pdl1ResultEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }

    /**
     * 其他送检组织
     */
    @AllArgsConstructor
    @Getter
    public enum OtherInspectionOrganizationsEnum {

        GASTRIC_TISSUE("gastric_tissue", "胃组织"),
        ANASTOMOTIC_SITE_NEAR_END("anastomotic_site_near_end", "吻合口近端"),
        ANASTOMOTIC_SITE_REMOTE_END("anastomotic_site_remote_end", "吻合口远端");

        private final String key;
        private final String desc;

        private static final List<MappingEnum<String, String>> TEMP_MAPPING = Arrays.stream(OtherInspectionOrganizationsEnum.values())
                .map(e -> new MappingEnum<>(e.getKey(), e.getDesc(), null))
                .collect(Collectors.toList());

        public static List<MappingEnum<String, String>> getList() {
            return TEMP_MAPPING;
        }
    }







}
